מבחן בקורס מבוא מורחב למדעי המחשב, CS1001.py עם תיקונים קלים והבהרות שניתנו במהלך המבחן ביה"ס למדעי המחשב, אונ' תל אביב

Transcription

1 מבחן בקורס מבוא מורחב למדעי המחשב, CS1001.py עם תיקונים קלים והבהרות שניתנו במהלך המבחן ביה"ס למדעי המחשב, אונ' תל אביב סמסטר ב' 2017, מועד ב, 7/9/2017 מרצים: פרופ' בני שור, ד"ר אמיר רובינשטיין מתרגלים: מיכל קליינבורט, אמיר גלעד משך הבחינה: 3 שעות. חומר עזר מותר: 2 דפי עזר (דו צדדיים) בגודל A4 כל אחד. במבחן 13 עמודים מודפסים בידקו שכולם בידיכן. בנוסף, בסוף הבחינה ישנו דף נוסף, ריק, לשימוש ב"מקרה חירום" בלבד. יש לכתוב את כל התשובות בטופס הבחינה. המחברת תשמש כטיוטה בלבד ולא תיבדק. יש לענות על כל השאלות. בכל השאלות, אלא אם נכתב במפורש אחרת: - אם עליכן לכתוב פונקציה, אין צורך לבדוק את תקינות הקלט שלה. - מותר להסתמך על סעיפים קודמים, גם אם לא עניתן עליהם. - ניתן לצטט טענות שנטענו בהרצאה או בשיעורי התרגול בסמסטר זה. במקרה זה יש לכתוב "בהרצאה/תרגול ראינו כי...". ציטוטים ממקורות אחרים יש להוכיח. - אם נדרשתן לתת חסם על סיבוכיות במונחי ( )O, יש לתת חסם עליון נמוך ביותר האפשרי, למשל אם הסיבוכיות היא 7n התשובה הנדרשת היא,O(n) ולא ) 2.O(n אנו ממליצים לא "להיתקע" על אף שאלה, אלא להמשיך לשאלות אחרות ולחזור לשאלה אח"כ. בכל סעיף ניתן לכתוב "איני יודע/ת" ולא לכתוב שום טקסט נוסף. במקרה זה יינתן 20% מציון הסעיף (מעוגל כלפי מטה). יש לכתוב את כל התשובות במקום המוקצב ובכתב קריא. תשובות ובהן חריגות משמעותיות מהמקום המוקצב, או תשובות הכתובות בכתב קטן מדי, לא ייקראו ולא יקבלו ניקוד, או שיקבלו ניקוד חלקי בלבד. תשובות שדורשות מאמצים רבים להבנתן גם כן עלולות לגרור הורדת ציון. טבלת ציונים: (לשימוש הבודקים) ניקוד ערך שאלה סה"כ בהצלחה! * הפניה במסמך זה היא בלשון נקבה ולשון זכר לסירוגין, מטעמי נוחות בלבד. כל הדרישות מיועדות לשני המגדרים באופן זהה.

2 שאלה (30 1 נק') בתרגיל הבית עסקתם במחלקה Sparse_Polynomial שייצגה פולינום דליל באמצעות מילון של פייתון. שאלה זו עוסקת במחלקה,Sparse_Matrix שמייצגת מטריצה דלילה, באופן המזכיר את המימוש הנ"ל. מטריצה דלילה היא מטריצה של מספרים שבה רוב האיברים שווים לערך ברירת מחדל נתון.(default_val) שימו לב שבשאלה זו default_val הוא אחד מהשדות של המחלקה ואינו בהכרח 0. class Sparse_Matrix(): def init (self, n, m, default_val=0): self.elements = {} #empty dictionary self.size = (n,m) self.default_val = default_val להלן מתודת האיתחול של המחלקה: כמו כן להלן המתודה setitem שמאפשרת לבצע השמה של ערך val שמיקומו בשורה i ובעמודה j במטריצה: def setitem (self, location_tuple, val): i = location_tuple[0] j = location_tuple[1] assert i < self.size[0] and j < self.size[1] if val!= self.default_val: self.elements[(i,j)] = val if (i,j) in self.elements and val == self.default_val: del self.elements[(i,j)] #delete element whose key is (i,j) return None כלומר המתודה מכניסה איברים (שערכם שונה מ- (self.default_val למילון.self.elements >>> mat[x,y] = z תזכורת: המתודה setitem תיקרא ע"י פייתון בעת ביצוע פקודה מהסוג הבא: כאשר mat הינו אובייקט מטיפוס,Sparse_Matrix הפרמטר location_tuple יקבל את הערך (x,y) שמייצג זוג אינדקסים, והפרמטר val יקבל את הערך z. נשים לב לכך ש- setitem רצה ב- (1)O בממוצע. דוגמאות הרצה: >>> mat = Sparse_Matrix(4,5,100) >>> mat[1,2] = 17 #location_tuple = (1,2), val=17 >>> mat[0,0] = 6 #location_tuple = (0,0), val=6 >>> mat[3,2] = 8 #location_tuple = (3,2), val=8 כעת, כל האיברים למעט שלושה שווים 100. נניח כי עבור המחלקה Sparse_Matrix מוגדרת גם המתודה repr שמחזירה מחרוזת שמייצגת מטריצה באופן הסטדנרטי. דוגמת הרצה: >>> mat

3 >>> mat[2,2] = 100 א. ג'ורדי הריץ את הפקודה הבאה על המטריצה mat שהוגדרה קודם. אילו מפתחות (זוגות ((i,j) יכיל המילון mat.elements לאחר פקודה זו? אין חשיבות לסדר הזוגות שתרשמו. המפתחות הם: ב. ממשו את מתודת location_tuple), getitem (self, שתיקרא ע"י פייתון בעת ביצוע פקודה מהסוג הבא: >>> z = mat[x,y] כאשר mat הינו אובייקט מטיפוס,Sparse_Matrix והפרמטר location_tuple יקבל את הערך y ובעמודה ה- x שמייצג זוג אינדקסים. על המתודה להחזיר את ערך האיבר שנמצא בשורה ה- (x,y) במטריצה. >>> a = mat[1,2] >>> a 17 >>> b = mat[0,1] >>> b 100 דוגמאות הרצה עבור mat מהדוגמא בעמוד הקודם: def getitem (self, location_tuple): i = location_tuple[0] j = location_tuple[1] assert i < self.size[0] and j < self.size[1] if : return ג. חיבור מטריצות בעלות מימדים זהים מתואר ע"י הדוגמה הבאה: a 0,0 a 0,1 a 0,2 b 0,0 b 0,1 b 0,2 c 0,0 c 0,1 c 0,2 a 1,0 a 1,1 a 1,2 + b 1,0 b 1,1 b 1,2 = c 1,0 c 1,1 c 1,2 a 2,0 a 2,1 a 2,2 b 2,0 b 2,1 b 2,2 c 2,0 c 2,1 c 2,2 כאשר c i,j = a i,j + b i,j לכל i, j בתחום החוקי. (המשך הסעיף בעמוד הבא) 3

4 ממשו את המתודה other) add (self, שמקבלת בנוסף לאובייקט המפעיל אובייקט נוסף other גם הוא מטיפוס מטריצה דלילה בעלת אותם מימדים. ערכי ברירת המחדל של שתי המטריצות אינם בהכרח שווים. המתודה מחזירה אובייקט חדש מטיפוס מטריצה דלילה שמייצגת את המטריצה שמתקבלת מחיבור המטריצות. דרישה: על המתודה לרוץ בסיבוכיות זמן ממוצעת ) 2,O(k 1 + k כאשר k 1 הינו מספר הערכים השונים מ- self.default_val במטריצה הראשונה,(self) ו- k 2 הינו מספר הערכים השונים מ-.(other) במטריצה השניה other.default_val מומלץ וכדאי להשתמש בפקודות הפייתון המתאימות שקוראות ל, getitem setitem מהסעיפים הקודמים. def add (self, other): assert isinstance(other, Sparse_Matrix) assert self.size == other.size n,m = self.size new_default = res = Sparse_Matrix( ) return res בסעיף זה נממש את המתודה func) apply_func(self, שמקבלת בנוסף לאובייקט המפעיל אובייקט נוסף func מטיפוס פונקציה. הניחו כי הפונקציה func המועברת היא פונקציה מהממשיים לעצמם (מקבלת פרמטר ממשי אחד ומחזירה מספר ממשי גם כן), ושהיא מוגדרת עבור כל הממשיים. i,j במיקום a i,j תחזיר אובייקט חדש מטיפוס מטריצה דלילה שבה ערכו של האיבר apply_func ד. הינו ) i,j.func(a על המתודה לרוץ בסיבוכיות זמן ממוצעת O(k) כאשר k הינו מספר הערכים השונים מ- self.default_val במטריצה.self הניחו כי דוגמאות הרצה עבור mat מתחילת השאלה: זמן הפעלה של func הוא קבוע. >>> mat.apply_func(lambda x : x + 1) השלימו את הקוד בעמוד הבא. 4

5 def apply_func(self, func): n,m = self.size new_default = res = Sparse_Matrix( ) return res ה. נניח שאנו רוצים להדפיס את כל האיברים בשורה ה- i (עבור i נתון כלשהו), ששונים מערך ה-.default_val למשל, ב- mat שלעיל, ועבור 1=i, הערך היחיד בשורה ששונה מ- 100 הוא 17. סדר ההדפסה אינו חשוב, והערכים יודפסו ע"י פקודת print פשוטה. נסמן ב -m את מספר העמודות במטריצה, וב- k את מספר האיברים במטריצה self ששונים מ.self.default_val 1) ממשו פעולה זו בסיבוכיות זמן קטנה ככל שתוכלו בהנחה ש: k. > m def get_line1(self, row): for : if : print(self[, ]) 2) ממשו פעולה זו בסיבוכיות זמן קטנה ככל שתוכלו בהנחה ש: m. > k def get_line2(self, row): for : if : print(self[, ]) 5

6 שאלה (25 2 נק') א. נתונה הפונקציה הבאה bubble_sort שבהינתן רשימה כקלט ממיינת אותה במקום (in-place) באמצעות אלגוריתם מיון בועות, שלא נלמד בכיתה. שימו לב שהפונקציה אינה מחזירה רשימה חדשה. def swap(l, i, j): tmp = L[i] L[i] = L[j] L[j] = tmp def bubble_sort(lst): n = len(lst) for i in range(n): #do n times (i not used) for j in range(n-1): if lst[j] > lst[j+1]: swap(lst, j, j+1) return None נסמן את אורך הרשימה L ב- n. מהו מספר הקריאות ל- swap כתלות ב- n במקרה הגרוע? תנו ביטוי מדוייק (לא סדר גודל). תשובה: תנו דוגמא לרשימה באורך 7 עבורה יתקבל מספר הקריאות הנ"ל: [,,,,,, ] נסמן את אורך הרשימה L ב- n. מהו מספר הקריאות ל- swap כתלות ב- n במקרה הטוב? תנו ביטוי מדוייק (לא סדר גודל). תשובה: תנו דוגמא לרשימה באורך 7 עבורה יתקבל מספר הקריאות הנ"ל: [,,,,,, ] 6

7 ב. מודדים את זמני הריצה של מיון בועות הנ"ל במקרה הגרוע על רשימות בגודל 1,000,000 ו- 2,000,000. איזו מהתוצאות הבאות (בעמוד הבא) סבירה ביותר? הקיפו בעיגול, והסבירו במשפט קצר תוך התייחסות לסיבוכיות זמן הריצה של הפונקציה. 2,000,000=n n=1,000, שניות 2 שניות 4 שניות 8 שניות 1 שניות 1 שניות 1 שניות 1 שניות ג. הפונקציה bubble_sort2 מציגה מימוש חלופי למיון בועות (בסעיף זה התעלמו מפקודת ההדפסה שבקוד). def bubble_sort2(lst): n = len(lst) for i in range(n-1): print("in iteration", i, "lst=", lst) swapped = False for j in range(n-i-1): if lst[j] > lst[j+1]: swapped = True swap(lst, j, j+1) if swapped == False: break return None O( ) מהי סיבוכיות זמן הריצה של bubble_sort2 במקרה הגרוע כתלות באורך הרשימה n? תנו דוגמא לרשימה באורך 7 עבורה תתקבל התנהגות המקרה הגרוע: [,,,,,, ] O( ) מהי סיבוכיות זמן הריצה של bubble_sort2 במקרה הטוב כתלות באורך הרשימה n? תנו דוגמא לרשימה באורך 7 עבורה תתקבל התנהגות המקרה הטוב: [,,,,,, ] 7

8 כעת התייחסו לפקודת ההדפסה והקיפו בעיגול את כל הרשימות שיכולות להיות מודפסות בפקודת ה print של bubble_sort2 בתחילת האיטרציה השלישית (שבה 2=i). אין צורך להסביר. In iteration 2 lst= [5,6,7,1,2,3,4].1 In iteration 2 lst= [1,2,3,4,5,6,7].2 In iteration 2 lst= [2,3,4,5,1,7,6].3 In iteration 2 lst= [4,3,2,1,5,6,7].4 ד. שאלה (12 3 נק') נתבקשתן לבצע את כל אחת מהפעולות בארבעת הסעיפים הבאים בשפת פייתון על המחשב הביתי שלכם (לא המחשב של, NASA אך גם לא מחשב אישי משנות ה- 80). עליכן לדרג את הסעיפים לפי דרישות משאבי זיכרון עולות (מהנמוך, זה שדורש הכי פחות משאבי זיכרון, לגבוה). כמו כן, עליכן לציין האם המשימה ניתנת לביצוע או שהמחשב ייתקע בגלל חוסר בזיכרון (ללא התחשבות באילוצי זמן ריצה). שימו לב שבאף סעיף אין פקודת הדפסה. c = 2** d = 2**(2** 1000)+ 11 def what(): n=0 while n < 2** : yield n n+=1 maybe = what() for i in range(2**20+1): a = next(maybe) ביצוע הפקודה ביצוע הפקודה הרצת הגדרת הפונקציה הבאה ואחריה (1 (2 (3 4) ביצוע הפקודה lst = [ i for i in range( 2**(2** 1000)+ 11)] (המשך השאלה בעמוד הבא) 8

9 דירוג על פי דרישות זיכרון (רישמו 1,2,3,4 במקומות המתאימים): הנמוך ביותר: ניתן / לא ניתן לביצוע (הקיפו בעיגול). השני מלמטה: ניתן / לא ניתן לביצוע (הקיפו בעיגול). השלישי מלמטה: ניתן / לא ניתן לביצוע (הקיפו בעיגול). הגבוה ביותר: ניתן / לא ניתן לביצוע (הקיפו בעיגול). 9

10 שאלה (23 4 נק') סטטיק ובן-אל שיחקו את משחק הקיסמים הבא: נתונה ערימה של num קיסמים, כאשר num הוא מספר טבעי חיובי. כמו כן, נתונה רשימה move_options של מספרים שלמים גדולים מ- 0 שמציינת את המהלכים האפשריים במשחק. הניחו שהערך 1 תמיד ימצא ברשימה move_options (הנחה זו משפרת מעט את הפתרון לבעיה כפי שתוגדר מייד). בכל שלב, השחקן הנוכחי בוחר מספר מהרשימה move_options ומסיר מהערימה מספר קיסמים השווה למספר שבחר. כעת הגיע תורו של השחקן הבא, המשחק ע"פ אותם כללים, וכן הלאה. השחקן שלוקח את הקיסם האחרון הוא המנצח במשחק. דוגמה למשחק עבור ערימה של num=9 קיסמים ורשימה :move_options=[1,4,2] סטטיק מתחיל ולוקח 4 קיסמים (נותרו 5 קיסמים בערימה) בן-אל לוקח 2 קיסמים (נותרו 3 קיסמים בערימה) סטטיק לוקח קיסם אחד (נותרו 2 קיסמים בערימה) בן-אל לוקח את הקיסם הנותר שני הקיסמים הנותרים ומנצח! למעשה, במקרה זה לסטטיק לא היתה שום דרך להבטיח לעצמו ניצחון, גם אילו בחר מהלכים אחרים. דוגמה נוספת עבור מהלך משחק שמתחיל עם ערימה של 5 קיסמים ורשימה :move_options=[3,1] סטטיק מתחיל ולוקח קיסם אחד (נותרו 4 קיסמים בערימה) בן-אל לוקח קיסם אחד (נותרו 3 קיסמים בערימה) סטטיק לוקח את 3 הקיסמים ומנצח. גו סטטיק! כל אחד מהשלבים במהלכו של משחק נקרא מצב. כמו במשחק הפופולרי "זלול" שלמדנו בכיתה, גם כאן, מצב כלשהו במהלך של משחק הוא מנצח אם אחד ההמשכים החוקיים שלו הוא מצב מפסיד, ומצב הוא מפסיד אם כל המשך חוקי שלו הוא מנצח. א. עליכן להשלים את מימוש המתודה move_options) win(num, שמחזירה True אם לשחקן הנוכחי קיימת אסטרטגיית ניצחון בהינתן ערימה עם num קיסמים ורשימת מהלכים אפשריים.False אחרת מחזירה,move_options שימו לב: עליכן להשלים את השורות החסרות בלבד, אך ניתן גם להשאיר את חלקן ריקות, אם אין לכן צורך בהן. קוד שיחרוג ממספר שורות אלו יאבד ניקוד. דוגמאות הרצה: >>> win(9, [1,4,2]) False >>> win(5, [3,1]) True 10

11 def win(num, move_options): assert 1 in move_options for move in move_options: if : return ב. ציירו את עץ הרקורסיה המתקבל עבור הקריאה הבאה: ([1,4,2].win(7, סמנו בעיגול צומת שמייצג מצב מנצח ובריבוע צומת שמייצג מצב מפסיד. אמיר ר. רוצה להוסיף מנגנון של ממואיזציה למימוש הרקורסיבי הנ"ל. לדעתו, תוספת כזו תשפר את סיבוכיות הזמן באופן משמעותי (כלומר מעבר לשיפור בקבוע). מיכל טוענת שתוספת כזו כן תשפר את זמן הריצה, אך בקבוע כפלי בלבד, כלומר הסיבוכיות (במונחי ( O לא תשתנה. בני חושב שאין בממואיזציה שום טעם בבעיה שלנו, כי היא לא תייעל כלל את זמן הריצה, אפילו לא בפעולה בודדת. אמיר ג. חושב ששלושת האחרים טועים, ושממואיזציה תגרום לזמן הריצה לעלות, עקב ביצוע פעולות מיותרות כגון גישה חסרת הצדקה למילון. מה מהבאים נכון? הקיפו בעיגול והסבירו בקצרה. a) אמיר ר. צודק b) מיכל צודקת c) בני צודק d) אמיר ג. צודק ג. 11

12 שאלה (10 5 נק') בשאלה זו נדון בניסיון לשיפור ביצועי הדחיסה באלגוריתם הדחיסה של זיו ולמפל, אשר נלמד בשיעור ובתרגול. פונקציה מרכזית במימוש אותו הצגנו היא הפונקציה,maxmatch אשר הקוד שלה מופיע לנוחותכם בהמשך. def maxmatch(t, p, w=2**12-1, max_length=2**5-1): ''' finds a maximum match of length k<=2**5-1 in a w long window, T[p:p+k] with T[p-m:p-m+k]. Returns m (offset) and k (match length) ''' assert isinstance(t,str( n = len(t) maxmatch = 0 offset = 0 for m in range(1, min(p+1, w)): k = 0 while k < min(n-p, max_length) and T[p-m+k] == T[p+k]: k += 1 # at this point, T[p-m:p-m+k]==T[p:p+k] if maxmatch < k : maxmatch = k offset = m return offset, maxmatch # returned offset is smallest one (closest to p) among all max matches (m starts at 1) הקוד לדחיסה שראינו בהרצאה הוא הקוד הבא, המייצר מחרוזת בפורמט ביניים def LZ3_compress(text, w=2**12-1, max_length=2**5-1): '''LZW compression of an ascii text. Produces a list comprising of either ascii characters or pairs [m,k] where m is an offset and k is a match (both are non negative integers) ''' result = [] n = len(text) p = 0 while p<n: if ord(text[p]) < 128: # ignores non Ascii chars m,k = maxmatch(text, p, w, max_length( if k < 3: result.append(text[p]) # a single char p += 1 else: result.append([m,k]) # two or more chars in match p += k return result # produces a list composed of chars and pairs 12

13 .[m,k] נתייחס לקוד זה כאל "הקוד המקורי". שימו לב כי בקוד זה, חזרות שאורכן פחות מ- 3 אינן מקודדות כזוג "הקוד המשופר" הוא קוד זהה, פרט לכך שבמקום השורה < 3 k מופיע בו התנאי :4 < k, דהיינו חזרות שאורכן פחות מ- 4 אינן מקודדות כזוג.[m,k] נתייחס לקוד זה כאל "הקוד המשופר". אנחנו מזכירים כי עבור הפרמטרים הדיפולטיים של הקוד, תו ASCII מיוצג על ידי 8=1+7 ביטים, ואילו זוג [m,k] מיוצג על ידי 18= ביטים. א. האם קיימת מחרוזת אשר דחיסתה תחת הקוד המקורי קצרה יותר מדחיסתה תחת הקוד המשופר? אם לדעתכן התשובה היא כן, הדגימו מחרוזת כזו (באורך 15 תווים לכל היותר) וציינו מהו אורכי המחרוזות הדחוסות (בביטים) תחת שתי השיטות. אם לא, ספקו טיעון משכנע (אין צורך בהוכחה מלאה). תשובה (הקיפו בעיגול): קיימת / לא קיימת דוגמה למחרוזת או טיעון משכנע, בהתאם לתשובתכם: ב. האם קיימת מחרוזת אשר דחיסתה תחת הקוד המשופר קצרה יותר מדחיסתה תחת הקוד המקורי? אם לדעתכן התשובה היא כן, הדגימו מחרוזת כזו (באורך 15 תווים לכל היותר) וציינו מהו אורכי המחרוזות הדחוסות (בביטים) תחת שתי השיטות. אם לא, ספקו טיעון משכנע (אין צורך בהוכחה מלאה). תשובה (הקיפו בעיגול): קיימת / לא קיימת דוגמה למחרוזת או טיעון משכנע, בהתאם לתשובתכם: בהצלחה! 13

14 דף נוסף, מיועד ל"מקרה חירום" 14